home *** CD-ROM | disk | FTP | other *** search
/ Visual Cafe 3 / Visual Cafe 3.ISO / Vcafe / Main.bin / jni.h < prev    next >
C/C++ Source or Header  |  1998-09-15  |  63KB  |  1,806 lines
  1. /*
  2.  * @(#)jni.h    1.28 97/05/19
  3.  *
  4.  * Copyright (c) 1993-1996 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies.
  10.  *
  11.  * The Java source code is the confidential and proprietary information
  12.  * of Sun Microsystems, Inc. ("Confidential Information").  You shall
  13.  * not disclose such Confidential Information and shall use it only in
  14.  * accordance with the terms of the license agreement you entered into
  15.  * with Sun.
  16.  *
  17.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  18.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  19.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  20.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  21.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  22.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  23.  */
  24.  
  25. /* 
  26.  * We used part of Netscape's Java Runtime Interface (JRI) as the starting
  27.  * point of our design and implementation.
  28.  */
  29.  
  30. /******************************************************************************
  31.  * Java Runtime Interface
  32.  * Copyright (c) 1996 Netscape Communications Corporation. All rights reserved.
  33.  *****************************************************************************/
  34.  
  35. #ifndef JNI_H
  36. #define JNI_H
  37.  
  38. #include <stdio.h>
  39. #include <stdarg.h>
  40.  
  41. /* jni_md.h contains the machine-dependent typedefs for jbyte, jint 
  42.    and jlong */ 
  43.  
  44. #include "jni_md.h"
  45.  
  46. #ifdef __cplusplus
  47. extern "C" {
  48. #endif
  49.  
  50. /*
  51.  * JNI Types
  52.  */
  53.  
  54. typedef unsigned char    jboolean;
  55. typedef unsigned short    jchar;
  56. typedef short        jshort;
  57. typedef float        jfloat;
  58. typedef double        jdouble;
  59.  
  60. typedef jint            jsize;
  61.  
  62. #ifdef __cplusplus
  63.  
  64. class _jobject {};
  65. class _jclass : public _jobject {};
  66. class _jthrowable : public _jobject {};
  67. class _jstring : public _jobject {};
  68. class _jarray : public _jobject {};
  69. class _jbooleanArray : public _jarray {};
  70. class _jbyteArray : public _jarray {};
  71. class _jcharArray : public _jarray {};
  72. class _jshortArray : public _jarray {};
  73. class _jintArray : public _jarray {};
  74. class _jlongArray : public _jarray {};
  75. class _jfloatArray : public _jarray {};
  76. class _jdoubleArray : public _jarray {};
  77. class _jobjectArray : public _jarray {};
  78.  
  79. typedef _jobject *jobject;
  80. typedef _jclass *jclass;
  81. typedef _jthrowable *jthrowable;
  82. typedef _jstring *jstring;
  83. typedef _jarray *jarray;
  84. typedef _jbooleanArray *jbooleanArray;
  85. typedef _jbyteArray *jbyteArray;
  86. typedef _jcharArray *jcharArray;
  87. typedef _jshortArray *jshortArray;
  88. typedef _jintArray *jintArray;
  89. typedef _jlongArray *jlongArray;
  90. typedef _jfloatArray *jfloatArray;
  91. typedef _jdoubleArray *jdoubleArray;
  92. typedef _jobjectArray *jobjectArray;
  93.  
  94. #else
  95.  
  96. struct _jobject;
  97.  
  98. typedef struct _jobject *jobject;
  99. typedef jobject jclass;
  100. typedef jobject jthrowable;
  101. typedef jobject jstring;
  102. typedef jobject jarray;
  103. typedef jarray jbooleanArray;
  104. typedef jarray jbyteArray;
  105. typedef jarray jcharArray;
  106. typedef jarray jshortArray;
  107. typedef jarray jintArray;
  108. typedef jarray jlongArray;
  109. typedef jarray jfloatArray;
  110. typedef jarray jdoubleArray;
  111. typedef jarray jobjectArray;
  112.  
  113. #endif
  114.  
  115. typedef jobject jref; /* For transition---not meant to be part of public 
  116.              API anymore.*/
  117.  
  118. typedef union jvalue {
  119.     jboolean z;
  120.     jbyte    b;
  121.     jchar    c;
  122.     jshort   s;
  123.     jint     i;
  124.     jlong    j;
  125.     jfloat   f;
  126.     jdouble  d;
  127.     jobject  l;
  128. } jvalue;
  129.  
  130. struct _jfieldID;
  131. typedef struct _jfieldID *jfieldID;
  132.  
  133. struct _jmethodID;
  134. typedef struct _jmethodID *jmethodID;
  135.  
  136. /*
  137.  * jboolean constants
  138.  */
  139.  
  140. #define JNI_FALSE 0
  141. #define JNI_TRUE 1
  142.  
  143. /*
  144.  * possible return values for JNI functions.
  145.  */
  146.  
  147. #define JNI_OK 0
  148. #define JNI_ERR (-1)
  149.  
  150. /*
  151.  * used in ReleaseScalarArrayElements
  152.  */
  153.   
  154. #define JNI_COMMIT 1
  155. #define JNI_ABORT 2
  156.  
  157. /*
  158.  * used in RegisterNatives to describe native method name, signature,
  159.  * and function pointer.
  160.  */
  161.  
  162. typedef struct {
  163.     char *name;
  164.     char *signature;
  165.     void *fnPtr;
  166. } JNINativeMethod;
  167.  
  168. /*
  169.  * JNI Native Method Interface.
  170.  */
  171.  
  172. struct JNINativeInterface_;
  173.  
  174. struct JNIEnv_;
  175.  
  176. #ifdef __cplusplus
  177. typedef JNIEnv_ JNIEnv;
  178. #else
  179. typedef const struct JNINativeInterface_ *JNIEnv;
  180. #endif
  181.  
  182. /*
  183.  * JNI Invocation Interface.
  184.  */
  185.  
  186. struct JNIInvokeInterface_;
  187.  
  188. struct JavaVM_;
  189.  
  190. #ifdef __cplusplus
  191. typedef JavaVM_ JavaVM;
  192. #else
  193. typedef const struct JNIInvokeInterface_ *JavaVM;
  194. #endif
  195.  
  196. struct JNINativeInterface_ {
  197.     void *reserved0;
  198.     void *reserved1;
  199.     void *reserved2;
  200.  
  201.     void *reserved3;
  202.     jint (JNICALL *GetVersion)(JNIEnv *env);
  203.  
  204.     jclass (JNICALL *DefineClass)
  205.       (JNIEnv *env, const char *name, jobject loader, const jbyte *buf, 
  206.        jsize len);
  207.     jclass (JNICALL *FindClass)
  208.       (JNIEnv *env, const char *name);
  209.  
  210.     void *reserved4;
  211.     void *reserved5;
  212.     void *reserved6;
  213.  
  214.     jclass (JNICALL *GetSuperclass)
  215.       (JNIEnv *env, jclass sub);
  216.     jboolean (JNICALL *IsAssignableFrom)
  217.       (JNIEnv *env, jclass sub, jclass sup);
  218.     void *reserved7;
  219.  
  220.  
  221.     jint (JNICALL *Throw)
  222.       (JNIEnv *env, jthrowable obj);
  223.     jint (JNICALL *ThrowNew)
  224.       (JNIEnv *env, jclass clazz, const char *msg);
  225.     jthrowable (JNICALL *ExceptionOccurred)
  226.       (JNIEnv *env);
  227.     void (JNICALL *ExceptionDescribe)
  228.       (JNIEnv *env);
  229.     void (JNICALL *ExceptionClear)
  230.       (JNIEnv *env);
  231.     void (JNICALL *FatalError)
  232.       (JNIEnv *env, const char *msg);
  233.     void *reserved8;
  234.     void *reserved9;
  235.  
  236.     jobject (JNICALL *NewGlobalRef)
  237.       (JNIEnv *env, jobject lobj);
  238.     void (JNICALL *DeleteGlobalRef)
  239.       (JNIEnv *env, jobject gref);
  240.     void (JNICALL *DeleteLocalRef)
  241.       (JNIEnv *env, jobject obj);
  242.     jboolean (JNICALL *IsSameObject)
  243.       (JNIEnv *env, jobject obj1, jobject obj2);
  244.     void *reserved10;
  245.     void *reserved11;
  246.  
  247.     jobject (JNICALL *AllocObject)
  248.       (JNIEnv *env, jclass clazz);
  249.     jobject (JNICALL *NewObject)
  250.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  251.     jobject (JNICALL *NewObjectV)
  252.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  253.     jobject (JNICALL *NewObjectA)
  254.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  255.  
  256.     jclass (JNICALL *GetObjectClass)
  257.       (JNIEnv *env, jobject obj);
  258.     jboolean (JNICALL *IsInstanceOf)
  259.       (JNIEnv *env, jobject obj, jclass clazz);
  260.  
  261.     jmethodID (JNICALL *GetMethodID)
  262.       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
  263.  
  264.     jobject (JNICALL *CallObjectMethod)
  265.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  266.     jobject (JNICALL *CallObjectMethodV)
  267.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  268.     jobject (JNICALL *CallObjectMethodA)
  269.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
  270.  
  271.     jboolean (JNICALL *CallBooleanMethod)
  272.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  273.     jboolean (JNICALL *CallBooleanMethodV)
  274.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  275.     jboolean (JNICALL *CallBooleanMethodA)
  276.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
  277.  
  278.     jbyte (JNICALL *CallByteMethod)
  279.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  280.     jbyte (JNICALL *CallByteMethodV)
  281.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  282.     jbyte (JNICALL *CallByteMethodA)
  283.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  284.  
  285.     jchar (JNICALL *CallCharMethod)
  286.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  287.     jchar (JNICALL *CallCharMethodV)
  288.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  289.     jchar (JNICALL *CallCharMethodA)
  290.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  291.  
  292.     jshort (JNICALL *CallShortMethod)
  293.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  294.     jshort (JNICALL *CallShortMethodV)
  295.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  296.     jshort (JNICALL *CallShortMethodA)
  297.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  298.  
  299.     jint (JNICALL *CallIntMethod)
  300.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  301.     jint (JNICALL *CallIntMethodV)
  302.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  303.     jint (JNICALL *CallIntMethodA)
  304.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  305.  
  306.     jlong (JNICALL *CallLongMethod)
  307.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  308.     jlong (JNICALL *CallLongMethodV)
  309.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  310.     jlong (JNICALL *CallLongMethodA)
  311.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  312.  
  313.     jfloat (JNICALL *CallFloatMethod)
  314.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  315.     jfloat (JNICALL *CallFloatMethodV)
  316.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  317.     jfloat (JNICALL *CallFloatMethodA)
  318.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  319.  
  320.     jdouble (JNICALL *CallDoubleMethod)
  321.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  322.     jdouble (JNICALL *CallDoubleMethodV)
  323.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  324.     jdouble (JNICALL *CallDoubleMethodA)
  325.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  326.  
  327.     void (JNICALL *CallVoidMethod)
  328.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  329.     void (JNICALL *CallVoidMethodV)
  330.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  331.     void (JNICALL *CallVoidMethodA)
  332.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
  333.  
  334.     jobject (JNICALL *CallNonvirtualObjectMethod)
  335.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  336.     jobject (JNICALL *CallNonvirtualObjectMethodV)
  337.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 
  338.        va_list args);
  339.     jobject (JNICALL *CallNonvirtualObjectMethodA)
  340.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 
  341.        jvalue * args);
  342.  
  343.     jboolean (JNICALL *CallNonvirtualBooleanMethod)
  344.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  345.     jboolean (JNICALL *CallNonvirtualBooleanMethodV)
  346.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  347.        va_list args);
  348.     jboolean (JNICALL *CallNonvirtualBooleanMethodA)
  349.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  350.        jvalue * args);
  351.  
  352.     jbyte (JNICALL *CallNonvirtualByteMethod)
  353.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  354.     jbyte (JNICALL *CallNonvirtualByteMethodV)
  355.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  356.        va_list args);
  357.     jbyte (JNICALL *CallNonvirtualByteMethodA)
  358.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 
  359.        jvalue *args);
  360.  
  361.     jchar (JNICALL *CallNonvirtualCharMethod)
  362.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  363.     jchar (JNICALL *CallNonvirtualCharMethodV)
  364.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  365.        va_list args);
  366.     jchar (JNICALL *CallNonvirtualCharMethodA)
  367.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  368.        jvalue *args);
  369.  
  370.     jshort (JNICALL *CallNonvirtualShortMethod)
  371.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  372.     jshort (JNICALL *CallNonvirtualShortMethodV)
  373.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  374.        va_list args);
  375.     jshort (JNICALL *CallNonvirtualShortMethodA)
  376.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  377.        jvalue *args);
  378.  
  379.     jint (JNICALL *CallNonvirtualIntMethod)
  380.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  381.     jint (JNICALL *CallNonvirtualIntMethodV)
  382.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  383.        va_list args);
  384.     jint (JNICALL *CallNonvirtualIntMethodA)
  385.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  386.        jvalue *args);
  387.  
  388.     jlong (JNICALL *CallNonvirtualLongMethod)
  389.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  390.     jlong (JNICALL *CallNonvirtualLongMethodV)
  391.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  392.        va_list args);
  393.     jlong (JNICALL *CallNonvirtualLongMethodA)
  394.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 
  395.        jvalue *args);
  396.  
  397.     jfloat (JNICALL *CallNonvirtualFloatMethod)
  398.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  399.     jfloat (JNICALL *CallNonvirtualFloatMethodV)
  400.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  401.        va_list args);
  402.     jfloat (JNICALL *CallNonvirtualFloatMethodA)
  403.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  404.        jvalue *args);
  405.  
  406.     jdouble (JNICALL *CallNonvirtualDoubleMethod)
  407.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  408.     jdouble (JNICALL *CallNonvirtualDoubleMethodV)
  409.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  410.        va_list args);
  411.     jdouble (JNICALL *CallNonvirtualDoubleMethodA)
  412.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  413.        jvalue *args);
  414.  
  415.     void (JNICALL *CallNonvirtualVoidMethod)
  416.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  417.     void (JNICALL *CallNonvirtualVoidMethodV)
  418.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  419.        va_list args);
  420.     void (JNICALL *CallNonvirtualVoidMethodA)
  421.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  422.        jvalue * args);
  423.  
  424.     jfieldID (JNICALL *GetFieldID)
  425.       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
  426.  
  427.     jobject (JNICALL *GetObjectField)
  428.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  429.     jboolean (JNICALL *GetBooleanField)
  430.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  431.     jbyte (JNICALL *GetByteField)
  432.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  433.     jchar (JNICALL *GetCharField)
  434.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  435.     jshort (JNICALL *GetShortField)
  436.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  437.     jint (JNICALL *GetIntField)
  438.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  439.     jlong (JNICALL *GetLongField)
  440.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  441.     jfloat (JNICALL *GetFloatField)
  442.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  443.     jdouble (JNICALL *GetDoubleField)
  444.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  445.  
  446.     void (JNICALL *SetObjectField)
  447.       (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val);
  448.     void (JNICALL *SetBooleanField)
  449.       (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val);
  450.     void (JNICALL *SetByteField)
  451.       (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val);
  452.     void (JNICALL *SetCharField)
  453.       (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val);
  454.     void (JNICALL *SetShortField)
  455.       (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val);
  456.     void (JNICALL *SetIntField)
  457.       (JNIEnv *env, jobject obj, jfieldID fieldID, jint val);
  458.     void (JNICALL *SetLongField)
  459.       (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val);
  460.     void (JNICALL *SetFloatField)
  461.       (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val);
  462.     void (JNICALL *SetDoubleField)
  463.       (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val);
  464.  
  465.     jmethodID (JNICALL *GetStaticMethodID)
  466.       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
  467.  
  468.     jobject (JNICALL *CallStaticObjectMethod)
  469.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  470.     jobject (JNICALL *CallStaticObjectMethodV)
  471.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  472.     jobject (JNICALL *CallStaticObjectMethodA)
  473.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  474.  
  475.     jboolean (JNICALL *CallStaticBooleanMethod)
  476.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  477.     jboolean (JNICALL *CallStaticBooleanMethodV)
  478.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  479.     jboolean (JNICALL *CallStaticBooleanMethodA)
  480.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  481.  
  482.     jbyte (JNICALL *CallStaticByteMethod)
  483.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  484.     jbyte (JNICALL *CallStaticByteMethodV)
  485.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  486.     jbyte (JNICALL *CallStaticByteMethodA)
  487.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  488.  
  489.     jchar (JNICALL *CallStaticCharMethod)
  490.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  491.     jchar (JNICALL *CallStaticCharMethodV)
  492.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  493.     jchar (JNICALL *CallStaticCharMethodA)
  494.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  495.  
  496.     jshort (JNICALL *CallStaticShortMethod)
  497.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  498.     jshort (JNICALL *CallStaticShortMethodV)
  499.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  500.     jshort (JNICALL *CallStaticShortMethodA)
  501.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  502.  
  503.     jint (JNICALL *CallStaticIntMethod)
  504.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  505.     jint (JNICALL *CallStaticIntMethodV)
  506.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  507.     jint (JNICALL *CallStaticIntMethodA)
  508.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  509.  
  510.     jlong (JNICALL *CallStaticLongMethod)
  511.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  512.     jlong (JNICALL *CallStaticLongMethodV)
  513.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  514.     jlong (JNICALL *CallStaticLongMethodA)
  515.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  516.  
  517.     jfloat (JNICALL *CallStaticFloatMethod)
  518.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  519.     jfloat (JNICALL *CallStaticFloatMethodV)
  520.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  521.     jfloat (JNICALL *CallStaticFloatMethodA)
  522.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  523.  
  524.     jdouble (JNICALL *CallStaticDoubleMethod)
  525.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  526.     jdouble (JNICALL *CallStaticDoubleMethodV)
  527.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  528.     jdouble (JNICALL *CallStaticDoubleMethodA)       
  529.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  530.  
  531.     void (JNICALL *CallStaticVoidMethod)
  532.       (JNIEnv *env, jclass cls, jmethodID methodID, ...);
  533.     void (JNICALL *CallStaticVoidMethodV)
  534.       (JNIEnv *env, jclass cls, jmethodID methodID, va_list args);
  535.     void (JNICALL *CallStaticVoidMethodA)
  536.       (JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args);
  537.  
  538.     jfieldID (JNICALL *GetStaticFieldID)
  539.       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
  540.     jobject (JNICALL *GetStaticObjectField)
  541.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  542.     jboolean (JNICALL *GetStaticBooleanField)
  543.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  544.     jbyte (JNICALL *GetStaticByteField)
  545.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  546.     jchar (JNICALL *GetStaticCharField)
  547.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  548.     jshort (JNICALL *GetStaticShortField)
  549.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  550.     jint (JNICALL *GetStaticIntField)
  551.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  552.     jlong (JNICALL *GetStaticLongField)
  553.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  554.     jfloat (JNICALL *GetStaticFloatField)
  555.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  556.     jdouble (JNICALL *GetStaticDoubleField)
  557.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  558.  
  559.     void (JNICALL *SetStaticObjectField)
  560.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value);
  561.     void (JNICALL *SetStaticBooleanField)
  562.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value);
  563.     void (JNICALL *SetStaticByteField)
  564.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value);
  565.     void (JNICALL *SetStaticCharField)
  566.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value);
  567.     void (JNICALL *SetStaticShortField)
  568.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value);
  569.     void (JNICALL *SetStaticIntField)
  570.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value);
  571.     void (JNICALL *SetStaticLongField)
  572.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value);
  573.     void (JNICALL *SetStaticFloatField)
  574.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value);
  575.     void (JNICALL *SetStaticDoubleField)
  576.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value);
  577.  
  578.     jstring (JNICALL *NewString)
  579.       (JNIEnv *env, const jchar *unicode, jsize len);
  580.     jsize (JNICALL *GetStringLength)
  581.       (JNIEnv *env, jstring str);
  582.     const jchar *(JNICALL *GetStringChars)
  583.       (JNIEnv *env, jstring str, jboolean *isCopy);
  584.     void (JNICALL *ReleaseStringChars)
  585.       (JNIEnv *env, jstring str, const jchar *chars);
  586.   
  587.     jstring (JNICALL *NewStringUTF)
  588.       (JNIEnv *env, const char *utf);
  589.     jsize (JNICALL *GetStringUTFLength)
  590.       (JNIEnv *env, jstring str);
  591.     const char* (JNICALL *GetStringUTFChars)
  592.       (JNIEnv *env, jstring str, jboolean *isCopy);
  593.     void (JNICALL *ReleaseStringUTFChars)
  594.       (JNIEnv *env, jstring str, const char* chars);
  595.   
  596.  
  597.     jsize (JNICALL *GetArrayLength)
  598.       (JNIEnv *env, jarray array);
  599.  
  600.     jobjectArray (JNICALL *NewObjectArray)
  601.       (JNIEnv *env, jsize len, jclass clazz, jobject init);
  602.     jobject (JNICALL *GetObjectArrayElement)
  603.       (JNIEnv *env, jobjectArray array, jsize index);
  604.     void (JNICALL *SetObjectArrayElement)
  605.       (JNIEnv *env, jobjectArray array, jsize index, jobject val);
  606.  
  607.     jbooleanArray (JNICALL *NewBooleanArray)
  608.       (JNIEnv *env, jsize len);
  609.     jbyteArray (JNICALL *NewByteArray)
  610.       (JNIEnv *env, jsize len);
  611.     jcharArray (JNICALL *NewCharArray)
  612.       (JNIEnv *env, jsize len);
  613.     jshortArray (JNICALL *NewShortArray)
  614.       (JNIEnv *env, jsize len);
  615.     jintArray (JNICALL *NewIntArray)
  616.       (JNIEnv *env, jsize len);
  617.     jlongArray (JNICALL *NewLongArray)
  618.       (JNIEnv *env, jsize len);
  619.     jfloatArray (JNICALL *NewFloatArray)
  620.       (JNIEnv *env, jsize len);
  621.     jdoubleArray (JNICALL *NewDoubleArray)
  622.       (JNIEnv *env, jsize len);
  623.  
  624.     jboolean * (JNICALL *GetBooleanArrayElements)
  625.       (JNIEnv *env, jbooleanArray array, jboolean *isCopy);
  626.     jbyte * (JNICALL *GetByteArrayElements)
  627.       (JNIEnv *env, jbyteArray array, jboolean *isCopy);
  628.     jchar * (JNICALL *GetCharArrayElements)
  629.       (JNIEnv *env, jcharArray array, jboolean *isCopy);
  630.     jshort * (JNICALL *GetShortArrayElements)
  631.       (JNIEnv *env, jshortArray array, jboolean *isCopy);
  632.     jint * (JNICALL *GetIntArrayElements)
  633.       (JNIEnv *env, jintArray array, jboolean *isCopy);
  634.     jlong * (JNICALL *GetLongArrayElements)
  635.       (JNIEnv *env, jlongArray array, jboolean *isCopy);
  636.     jfloat * (JNICALL *GetFloatArrayElements)
  637.       (JNIEnv *env, jfloatArray array, jboolean *isCopy);
  638.     jdouble * (JNICALL *GetDoubleArrayElements)
  639.       (JNIEnv *env, jdoubleArray array, jboolean *isCopy);
  640.  
  641.     void (JNICALL *ReleaseBooleanArrayElements)
  642.       (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode);
  643.     void (JNICALL *ReleaseByteArrayElements)
  644.       (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode);
  645.     void (JNICALL *ReleaseCharArrayElements)
  646.       (JNIEnv *env, jcharArray array, jchar *elems, jint mode);
  647.     void (JNICALL *ReleaseShortArrayElements)
  648.       (JNIEnv *env, jshortArray array, jshort *elems, jint mode);
  649.     void (JNICALL *ReleaseIntArrayElements)
  650.       (JNIEnv *env, jintArray array, jint *elems, jint mode);
  651.     void (JNICALL *ReleaseLongArrayElements)
  652.       (JNIEnv *env, jlongArray array, jlong *elems, jint mode);
  653.     void (JNICALL *ReleaseFloatArrayElements)
  654.       (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode);
  655.     void (JNICALL *ReleaseDoubleArrayElements)
  656.       (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode);
  657.  
  658.     void (JNICALL *GetBooleanArrayRegion)
  659.       (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
  660.     void (JNICALL *GetByteArrayRegion)
  661.       (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
  662.     void (JNICALL *GetCharArrayRegion)
  663.       (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
  664.     void (JNICALL *GetShortArrayRegion)
  665.       (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
  666.     void (JNICALL *GetIntArrayRegion)
  667.       (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
  668.     void (JNICALL *GetLongArrayRegion)
  669.       (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
  670.     void (JNICALL *GetFloatArrayRegion)
  671.       (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
  672.     void (JNICALL *GetDoubleArrayRegion)
  673.       (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
  674.  
  675.     void (JNICALL *SetBooleanArrayRegion)
  676.       (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
  677.     void (JNICALL *SetByteArrayRegion)
  678.       (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
  679.     void (JNICALL *SetCharArrayRegion)
  680.       (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
  681.     void (JNICALL *SetShortArrayRegion)
  682.       (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
  683.     void (JNICALL *SetIntArrayRegion)
  684.       (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
  685.     void (JNICALL *SetLongArrayRegion)
  686.       (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
  687.     void (JNICALL *SetFloatArrayRegion)
  688.       (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
  689.     void (JNICALL *SetDoubleArrayRegion)
  690.       (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
  691.  
  692.     jint (JNICALL *RegisterNatives)
  693.       (JNIEnv *env, jclass clazz, const JNINativeMethod *methods, 
  694.        jint nMethods);
  695.     jint (JNICALL *UnregisterNatives)
  696.       (JNIEnv *env, jclass clazz);
  697.  
  698.     jint (JNICALL *MonitorEnter)
  699.       (JNIEnv *env, jobject obj);
  700.     jint (JNICALL *MonitorExit)
  701.       (JNIEnv *env, jobject obj);
  702.  
  703.     jint (JNICALL *GetJavaVM)
  704.       (JNIEnv *env, JavaVM **vm);
  705. };
  706.  
  707. /*
  708.  * We use inlined functions for C++ so that programmers can write:
  709.  * 
  710.  *    env->FindClass("java/lang/String")
  711.  *
  712.  * in C++ rather than:
  713.  *
  714.  *    (*env)->FindClass(env, "java/lang/String")
  715.  *
  716.  * in C.
  717.  */
  718.  
  719. struct JNIEnv_ {
  720.     const struct JNINativeInterface_ *functions;
  721.     void *reserved0;
  722.     void *reserved1[6];
  723. #ifdef __cplusplus
  724.  
  725.     jint GetVersion() {
  726.         return functions->GetVersion(this);
  727.     }
  728.     jclass DefineClass(const char *name, jobject loader, const jbyte *buf,
  729.                jsize len) {
  730.         return functions->DefineClass(this, name, loader, buf, len);
  731.     }
  732.     jclass FindClass(const char *name) {
  733.         return functions->FindClass(this, name);
  734.     }
  735.     jclass GetSuperclass(jclass sub) {
  736.         return functions->GetSuperclass(this, sub);
  737.     }
  738.     jboolean IsAssignableFrom(jclass sub, jclass sup) {
  739.         return functions->IsAssignableFrom(this, sub, sup);
  740.     }
  741.  
  742.     jint Throw(jthrowable obj) {
  743.         return functions->Throw(this, obj);
  744.     }    
  745.     jint ThrowNew(jclass clazz, const char *msg) {
  746.         return functions->ThrowNew(this, clazz, msg);
  747.     }
  748.     jthrowable ExceptionOccurred() {
  749.         return functions->ExceptionOccurred(this);
  750.     }
  751.     void ExceptionDescribe() {
  752.         functions->ExceptionDescribe(this);
  753.     }
  754.     void ExceptionClear() {
  755.         functions->ExceptionClear(this);
  756.     }
  757.     void FatalError(const char *msg) {
  758.         functions->FatalError(this, msg);
  759.     }
  760.  
  761.     jobject NewGlobalRef(jobject lobj) {
  762.         return functions->NewGlobalRef(this,lobj);
  763.     }
  764.     void DeleteGlobalRef(jobject gref) {
  765.         functions->DeleteGlobalRef(this,gref);
  766.     }
  767.     void DeleteLocalRef(jobject obj) {
  768.         functions->DeleteLocalRef(this, obj);
  769.     }
  770.  
  771.     jboolean IsSameObject(jobject obj1, jobject obj2) {
  772.         return functions->IsSameObject(this,obj1,obj2);
  773.     }
  774.  
  775.     jobject AllocObject(jclass clazz) {
  776.         return functions->AllocObject(this,clazz);
  777.     }
  778.     jobject NewObject(jclass clazz, jmethodID methodID, ...) {
  779.         va_list args;
  780.     jobject result;
  781.     va_start(args, methodID);
  782.         result = functions->NewObjectV(this,clazz,methodID,args);
  783.     va_end(args);
  784.     return result;
  785.     }
  786.     jobject NewObjectV(jclass clazz, jmethodID methodID, 
  787.                va_list args) {
  788.         return functions->NewObjectV(this,clazz,methodID,args);
  789.     }
  790.     jobject NewObjectA(jclass clazz, jmethodID methodID, 
  791.                jvalue *args) {
  792.         return functions->NewObjectA(this,clazz,methodID,args);
  793.     }
  794.  
  795.     jclass GetObjectClass(jobject obj) {
  796.         return functions->GetObjectClass(this,obj);
  797.     }
  798.     jboolean IsInstanceOf(jobject obj, jclass clazz) {
  799.         return functions->IsInstanceOf(this,obj,clazz);
  800.     }
  801.  
  802.     jmethodID GetMethodID(jclass clazz, const char *name, 
  803.               const char *sig) {
  804.         return functions->GetMethodID(this,clazz,name,sig);
  805.     }
  806.  
  807.     jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) {
  808.         va_list args;
  809.     jobject result;
  810.     va_start(args,methodID);
  811.     result = functions->CallObjectMethodV(this,obj,methodID,args);
  812.     va_end(args);
  813.     return result;
  814.     }
  815.     jobject CallObjectMethodV(jobject obj, jmethodID methodID, 
  816.             va_list args) {
  817.         return functions->CallObjectMethodV(this,obj,methodID,args);
  818.     }
  819.     jobject CallObjectMethodA(jobject obj, jmethodID methodID, 
  820.             jvalue * args) {
  821.         return functions->CallObjectMethodA(this,obj,methodID,args);
  822.     }
  823.  
  824.     jboolean CallBooleanMethod(jobject obj, 
  825.                    jmethodID methodID, ...) {
  826.         va_list args;
  827.     jboolean result;
  828.     va_start(args,methodID);
  829.     result = functions->CallBooleanMethodV(this,obj,methodID,args);
  830.     va_end(args);
  831.     return result;
  832.     }
  833.     jboolean CallBooleanMethodV(jobject obj, jmethodID methodID, 
  834.                 va_list args) {
  835.         return functions->CallBooleanMethodV(this,obj,methodID,args);
  836.     }
  837.     jboolean CallBooleanMethodA(jobject obj, jmethodID methodID, 
  838.                 jvalue * args) {
  839.         return functions->CallBooleanMethodA(this,obj,methodID, args);
  840.     }
  841.  
  842.     jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) {
  843.         va_list args;
  844.     jbyte result;
  845.     va_start(args,methodID);
  846.     result = functions->CallByteMethodV(this,obj,methodID,args);
  847.     va_end(args);
  848.     return result;
  849.     }
  850.     jbyte CallByteMethodV(jobject obj, jmethodID methodID, 
  851.               va_list args) {
  852.         return functions->CallByteMethodV(this,obj,methodID,args);
  853.     }
  854.     jbyte CallByteMethodA(jobject obj, jmethodID methodID, 
  855.               jvalue * args) {
  856.         return functions->CallByteMethodA(this,obj,methodID,args);
  857.     }
  858.  
  859.     jchar CallCharMethod(jobject obj, jmethodID methodID, ...) {
  860.         va_list args;
  861.     jchar result;
  862.     va_start(args,methodID);
  863.     result = functions->CallCharMethodV(this,obj,methodID,args);
  864.     va_end(args);
  865.     return result;
  866.     }
  867.     jchar CallCharMethodV(jobject obj, jmethodID methodID, 
  868.               va_list args) {
  869.         return functions->CallCharMethodV(this,obj,methodID,args);
  870.     }
  871.     jchar CallCharMethodA(jobject obj, jmethodID methodID, 
  872.               jvalue * args) {
  873.         return functions->CallCharMethodA(this,obj,methodID,args);
  874.     }
  875.  
  876.     jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {
  877.         va_list args;
  878.     jshort result;
  879.     va_start(args,methodID);
  880.     result = functions->CallShortMethodV(this,obj,methodID,args);
  881.     va_end(args);
  882.     return result;
  883.     }
  884.     jshort CallShortMethodV(jobject obj, jmethodID methodID, 
  885.                 va_list args) {
  886.         return functions->CallShortMethodV(this,obj,methodID,args);
  887.     }
  888.     jshort CallShortMethodA(jobject obj, jmethodID methodID, 
  889.                 jvalue * args) {
  890.         return functions->CallShortMethodA(this,obj,methodID,args);
  891.     }
  892.  
  893.     jint CallIntMethod(jobject obj, jmethodID methodID, ...) {
  894.         va_list args;
  895.     jint result;
  896.     va_start(args,methodID);
  897.     result = functions->CallIntMethodV(this,obj,methodID,args);
  898.     va_end(args);
  899.     return result;
  900.     }
  901.     jint CallIntMethodV(jobject obj, jmethodID methodID, 
  902.             va_list args) {
  903.         return functions->CallIntMethodV(this,obj,methodID,args);
  904.     }
  905.     jint CallIntMethodA(jobject obj, jmethodID methodID, 
  906.             jvalue * args) {
  907.         return functions->CallIntMethodA(this,obj,methodID,args);
  908.     }
  909.  
  910.     jlong CallLongMethod(jobject obj, jmethodID methodID, ...) {
  911.         va_list args;
  912.     jlong result;
  913.     va_start(args,methodID);
  914.     result = functions->CallLongMethodV(this,obj,methodID,args);
  915.     va_end(args);
  916.     return result;
  917.     }
  918.     jlong CallLongMethodV(jobject obj, jmethodID methodID, 
  919.               va_list args) {
  920.         return functions->CallLongMethodV(this,obj,methodID,args);
  921.     }
  922.     jlong CallLongMethodA(jobject obj, jmethodID methodID, 
  923.               jvalue * args) {
  924.         return functions->CallLongMethodA(this,obj,methodID,args);
  925.     }
  926.  
  927.     jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) {
  928.         va_list args;
  929.     jfloat result;
  930.     va_start(args,methodID);
  931.     result = functions->CallFloatMethodV(this,obj,methodID,args);
  932.     va_end(args);
  933.     return result;
  934.     }
  935.     jfloat CallFloatMethodV(jobject obj, jmethodID methodID, 
  936.                 va_list args) {
  937.         return functions->CallFloatMethodV(this,obj,methodID,args);
  938.     }
  939.     jfloat CallFloatMethodA(jobject obj, jmethodID methodID, 
  940.                 jvalue * args) {
  941.         return functions->CallFloatMethodA(this,obj,methodID,args);
  942.     }
  943.  
  944.     jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) {
  945.         va_list args;
  946.     jdouble result;
  947.     va_start(args,methodID);
  948.     result = functions->CallDoubleMethodV(this,obj,methodID,args);
  949.     va_end(args);
  950.     return result;
  951.     }
  952.     jdouble CallDoubleMethodV(jobject obj, jmethodID methodID, 
  953.             va_list args) {
  954.         return functions->CallDoubleMethodV(this,obj,methodID,args);
  955.     }
  956.     jdouble CallDoubleMethodA(jobject obj, jmethodID methodID, 
  957.             jvalue * args) {
  958.         return functions->CallDoubleMethodA(this,obj,methodID,args);
  959.     }
  960.  
  961.     void CallVoidMethod(jobject obj, jmethodID methodID, ...) {
  962.         va_list args;
  963.     va_start(args,methodID);
  964.     functions->CallVoidMethodV(this,obj,methodID,args);
  965.     va_end(args);
  966.     }
  967.     void CallVoidMethodV(jobject obj, jmethodID methodID, 
  968.              va_list args) {
  969.         functions->CallVoidMethodV(this,obj,methodID,args);
  970.     }
  971.     void CallVoidMethodA(jobject obj, jmethodID methodID, 
  972.              jvalue * args) {
  973.         functions->CallVoidMethodA(this,obj,methodID,args);
  974.     }
  975.  
  976.     jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz, 
  977.                        jmethodID methodID, ...) {
  978.         va_list args;
  979.     jobject result;
  980.     va_start(args,methodID);
  981.     result = functions->CallNonvirtualObjectMethodV(this,obj,clazz,
  982.                             methodID,args);
  983.     va_end(args);
  984.     return result;
  985.     }
  986.     jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz, 
  987.                     jmethodID methodID, va_list args) {
  988.         return functions->CallNonvirtualObjectMethodV(this,obj,clazz,
  989.                               methodID,args);
  990.     }
  991.     jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz, 
  992.                     jmethodID methodID, jvalue * args) {
  993.         return functions->CallNonvirtualObjectMethodA(this,obj,clazz,
  994.                               methodID,args);
  995.     }
  996.  
  997.     jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz, 
  998.                      jmethodID methodID, ...) {
  999.         va_list args;
  1000.     jboolean result;
  1001.     va_start(args,methodID);
  1002.     result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
  1003.                              methodID,args);
  1004.     va_end(args);
  1005.     return result;
  1006.     }
  1007.     jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz, 
  1008.                       jmethodID methodID, va_list args) {
  1009.         return functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
  1010.                                methodID,args);
  1011.     }
  1012.     jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz, 
  1013.                       jmethodID methodID, jvalue * args) {
  1014.         return functions->CallNonvirtualBooleanMethodA(this,obj,clazz,
  1015.                                methodID, args);
  1016.     }
  1017.  
  1018.     jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz, 
  1019.                    jmethodID methodID, ...) {
  1020.         va_list args;
  1021.     jbyte result;
  1022.     va_start(args,methodID);
  1023.     result = functions->CallNonvirtualByteMethodV(this,obj,clazz,
  1024.                               methodID,args);
  1025.     va_end(args);
  1026.     return result;
  1027.     }
  1028.     jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz, 
  1029.                     jmethodID methodID, va_list args) {
  1030.         return functions->CallNonvirtualByteMethodV(this,obj,clazz,
  1031.                             methodID,args);
  1032.     }
  1033.     jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz, 
  1034.                     jmethodID methodID, jvalue * args) {
  1035.         return functions->CallNonvirtualByteMethodA(this,obj,clazz,
  1036.                             methodID,args);
  1037.     }
  1038.  
  1039.     jchar CallNonvirtualCharMethod(jobject obj, jclass clazz, 
  1040.                    jmethodID methodID, ...) {
  1041.         va_list args;
  1042.     jchar result;
  1043.     va_start(args,methodID);
  1044.     result = functions->CallNonvirtualCharMethodV(this,obj,clazz,
  1045.                               methodID,args);
  1046.     va_end(args);
  1047.     return result;
  1048.     }
  1049.     jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz, 
  1050.                     jmethodID methodID, va_list args) {
  1051.         return functions->CallNonvirtualCharMethodV(this,obj,clazz,
  1052.                             methodID,args);
  1053.     }
  1054.     jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz, 
  1055.                     jmethodID methodID, jvalue * args) {
  1056.         return functions->CallNonvirtualCharMethodA(this,obj,clazz,
  1057.                             methodID,args);
  1058.     }
  1059.  
  1060.     jshort CallNonvirtualShortMethod(jobject obj, jclass clazz, 
  1061.                      jmethodID methodID, ...) {
  1062.         va_list args;
  1063.     jshort result;
  1064.     va_start(args,methodID);
  1065.     result = functions->CallNonvirtualShortMethodV(this,obj,clazz,
  1066.                                methodID,args);
  1067.     va_end(args);
  1068.     return result;
  1069.     }
  1070.     jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz, 
  1071.                       jmethodID methodID, va_list args) {
  1072.         return functions->CallNonvirtualShortMethodV(this,obj,clazz,
  1073.                              methodID,args);
  1074.     }
  1075.     jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz,
  1076.                       jmethodID methodID, jvalue * args) {
  1077.         return functions->CallNonvirtualShortMethodA(this,obj,clazz,
  1078.                              methodID,args);
  1079.     }
  1080.  
  1081.     jint CallNonvirtualIntMethod(jobject obj, jclass clazz, 
  1082.                  jmethodID methodID, ...) {
  1083.         va_list args;
  1084.     jint result;
  1085.     va_start(args,methodID);
  1086.     result = functions->CallNonvirtualIntMethodV(this,obj,clazz,
  1087.                              methodID,args);
  1088.     va_end(args);
  1089.     return result;
  1090.     }
  1091.     jint CallNonvirtualIntMethodV(jobject obj, jclass clazz, 
  1092.                   jmethodID methodID, va_list args) {
  1093.         return functions->CallNonvirtualIntMethodV(this,obj,clazz,
  1094.                            methodID,args);
  1095.     }
  1096.     jint CallNonvirtualIntMethodA(jobject obj, jclass clazz, 
  1097.                   jmethodID methodID, jvalue * args) {
  1098.         return functions->CallNonvirtualIntMethodA(this,obj,clazz,
  1099.                            methodID,args);
  1100.     }
  1101.  
  1102.     jlong CallNonvirtualLongMethod(jobject obj, jclass clazz,
  1103.                    jmethodID methodID, ...) {
  1104.         va_list args;
  1105.     jlong result;
  1106.     va_start(args,methodID);
  1107.     result = functions->CallNonvirtualLongMethodV(this,obj,clazz,
  1108.                               methodID,args);
  1109.     va_end(args);
  1110.     return result;
  1111.     }
  1112.     jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz,
  1113.                     jmethodID methodID, va_list args) {
  1114.         return functions->CallNonvirtualLongMethodV(this,obj,clazz,
  1115.                             methodID,args);
  1116.     }
  1117.     jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz, 
  1118.                     jmethodID methodID, jvalue * args) {
  1119.         return functions->CallNonvirtualLongMethodA(this,obj,clazz,
  1120.                             methodID,args);
  1121.     }
  1122.  
  1123.     jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz, 
  1124.                      jmethodID methodID, ...) {
  1125.         va_list args;
  1126.     jfloat result;
  1127.     va_start(args,methodID);
  1128.     result = functions->CallNonvirtualFloatMethodV(this,obj,clazz,
  1129.                                methodID,args);
  1130.     va_end(args);
  1131.     return result;
  1132.     }
  1133.     jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz,
  1134.                       jmethodID methodID, 
  1135.                       va_list args) {
  1136.         return functions->CallNonvirtualFloatMethodV(this,obj,clazz,
  1137.                              methodID,args);
  1138.     }
  1139.     jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz, 
  1140.                       jmethodID methodID, 
  1141.                       jvalue * args) {
  1142.         return functions->CallNonvirtualFloatMethodA(this,obj,clazz,
  1143.                              methodID,args);
  1144.     }
  1145.  
  1146.     jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz,
  1147.                        jmethodID methodID, ...) {
  1148.         va_list args;
  1149.     jdouble result;
  1150.     va_start(args,methodID);
  1151.     result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
  1152.                             methodID,args);
  1153.     va_end(args);
  1154.     return result;
  1155.     }
  1156.     jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz,
  1157.                     jmethodID methodID, 
  1158.                     va_list args) {
  1159.         return functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
  1160.                               methodID,args);
  1161.     }
  1162.     jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz, 
  1163.                     jmethodID methodID, 
  1164.                     jvalue * args) {
  1165.         return functions->CallNonvirtualDoubleMethodA(this,obj,clazz,
  1166.                               methodID,args);
  1167.     }
  1168.  
  1169.     void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
  1170.                   jmethodID methodID, ...) {
  1171.         va_list args;
  1172.     va_start(args,methodID);
  1173.     functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
  1174.     va_end(args);
  1175.     }
  1176.     void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,
  1177.                    jmethodID methodID, 
  1178.                    va_list args) {
  1179.         functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
  1180.     }
  1181.     void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
  1182.                    jmethodID methodID, 
  1183.                    jvalue * args) {
  1184.         functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args);
  1185.     }
  1186.  
  1187.     jfieldID GetFieldID(jclass clazz, const char *name, 
  1188.             const char *sig) {
  1189.         return functions->GetFieldID(this,clazz,name,sig);
  1190.     }
  1191.  
  1192.     jobject GetObjectField(jobject obj, jfieldID fieldID) {
  1193.         return functions->GetObjectField(this,obj,fieldID);
  1194.     }
  1195.     jboolean GetBooleanField(jobject obj, jfieldID fieldID) {
  1196.         return functions->GetBooleanField(this,obj,fieldID);
  1197.     }
  1198.     jbyte GetByteField(jobject obj, jfieldID fieldID) {
  1199.         return functions->GetByteField(this,obj,fieldID);
  1200.     }
  1201.     jchar GetCharField(jobject obj, jfieldID fieldID) {
  1202.         return functions->GetCharField(this,obj,fieldID);
  1203.     }
  1204.     jshort GetShortField(jobject obj, jfieldID fieldID) {
  1205.         return functions->GetShortField(this,obj,fieldID);
  1206.     }
  1207.     jint GetIntField(jobject obj, jfieldID fieldID) {
  1208.         return functions->GetIntField(this,obj,fieldID);
  1209.     }
  1210.     jlong GetLongField(jobject obj, jfieldID fieldID) {
  1211.         return functions->GetLongField(this,obj,fieldID);
  1212.     }
  1213.     jfloat GetFloatField(jobject obj, jfieldID fieldID) {
  1214.         return functions->GetFloatField(this,obj,fieldID);
  1215.     }
  1216.     jdouble GetDoubleField(jobject obj, jfieldID fieldID) {
  1217.         return functions->GetDoubleField(this,obj,fieldID);
  1218.     }
  1219.  
  1220.     void SetObjectField(jobject obj, jfieldID fieldID, jobject val) {
  1221.         functions->SetObjectField(this,obj,fieldID,val);
  1222.     }
  1223.     void SetBooleanField(jobject obj, jfieldID fieldID, 
  1224.              jboolean val) {
  1225.         functions->SetBooleanField(this,obj,fieldID,val);
  1226.     }
  1227.     void SetByteField(jobject obj, jfieldID fieldID, 
  1228.               jbyte val) {
  1229.         functions->SetByteField(this,obj,fieldID,val);
  1230.     }
  1231.     void SetCharField(jobject obj, jfieldID fieldID, 
  1232.               jchar val) {
  1233.         functions->SetCharField(this,obj,fieldID,val);
  1234.     }
  1235.     void SetShortField(jobject obj, jfieldID fieldID,
  1236.                jshort val) {
  1237.         functions->SetShortField(this,obj,fieldID,val);
  1238.     }
  1239.     void SetIntField(jobject obj, jfieldID fieldID, 
  1240.              jint val) {
  1241.         functions->SetIntField(this,obj,fieldID,val);
  1242.     }
  1243.     void SetLongField(jobject obj, jfieldID fieldID, 
  1244.               jlong val) {
  1245.         functions->SetLongField(this,obj,fieldID,val);
  1246.     }
  1247.     void SetFloatField(jobject obj, jfieldID fieldID, 
  1248.                jfloat val) {
  1249.         functions->SetFloatField(this,obj,fieldID,val);
  1250.     }
  1251.     void SetDoubleField(jobject obj, jfieldID fieldID, 
  1252.             jdouble val) {
  1253.         functions->SetDoubleField(this,obj,fieldID,val);
  1254.     }
  1255.  
  1256.     jmethodID GetStaticMethodID(jclass clazz, const char *name, 
  1257.                 const char *sig) {
  1258.         return functions->GetStaticMethodID(this,clazz,name,sig);
  1259.     }
  1260.  
  1261.     jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID, 
  1262.                  ...) {
  1263.         va_list args;
  1264.     jobject result;
  1265.     va_start(args,methodID);
  1266.     result = functions->CallStaticObjectMethodV(this,clazz,methodID,args);
  1267.     va_end(args);
  1268.     return result;
  1269.     }
  1270.     jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID, 
  1271.                   va_list args) {
  1272.         return functions->CallStaticObjectMethodV(this,clazz,methodID,args);
  1273.     }
  1274.     jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID, 
  1275.                   jvalue *args) {
  1276.         return functions->CallStaticObjectMethodA(this,clazz,methodID,args);
  1277.     }
  1278.  
  1279.     jboolean CallStaticBooleanMethod(jclass clazz, 
  1280.                      jmethodID methodID, ...) {
  1281.         va_list args;
  1282.     jboolean result;
  1283.     va_start(args,methodID);
  1284.     result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
  1285.     va_end(args);
  1286.     return result;
  1287.     }
  1288.     jboolean CallStaticBooleanMethodV(jclass clazz,
  1289.                       jmethodID methodID, va_list args) {
  1290.         return functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
  1291.     }
  1292.     jboolean CallStaticBooleanMethodA(jclass clazz,
  1293.                       jmethodID methodID, jvalue *args) {
  1294.         return functions->CallStaticBooleanMethodA(this,clazz,methodID,args);
  1295.     }
  1296.  
  1297.     jbyte CallStaticByteMethod(jclass clazz,
  1298.                    jmethodID methodID, ...) {
  1299.         va_list args;
  1300.     jbyte result;
  1301.     va_start(args,methodID);
  1302.     result = functions->CallStaticByteMethodV(this,clazz,methodID,args);
  1303.     va_end(args);
  1304.     return result;
  1305.     }
  1306.     jbyte CallStaticByteMethodV(jclass clazz,
  1307.                 jmethodID methodID, va_list args) {
  1308.         return functions->CallStaticByteMethodV(this,clazz,methodID,args);
  1309.     }
  1310.     jbyte CallStaticByteMethodA(jclass clazz, 
  1311.                 jmethodID methodID, jvalue *args) {
  1312.         return functions->CallStaticByteMethodA(this,clazz,methodID,args);
  1313.     }
  1314.  
  1315.     jchar CallStaticCharMethod(jclass clazz,
  1316.                    jmethodID methodID, ...) {
  1317.         va_list args;
  1318.     jchar result;
  1319.     va_start(args,methodID);
  1320.     result = functions->CallStaticCharMethodV(this,clazz,methodID,args);
  1321.     va_end(args);
  1322.     return result;
  1323.     }
  1324.     jchar CallStaticCharMethodV(jclass clazz,
  1325.                 jmethodID methodID, va_list args) {
  1326.         return functions->CallStaticCharMethodV(this,clazz,methodID,args);
  1327.     }
  1328.     jchar CallStaticCharMethodA(jclass clazz,
  1329.                 jmethodID methodID, jvalue *args) {
  1330.         return functions->CallStaticCharMethodA(this,clazz,methodID,args);
  1331.     }
  1332.  
  1333.     jshort CallStaticShortMethod(jclass clazz,
  1334.                  jmethodID methodID, ...) {
  1335.         va_list args;
  1336.     jshort result;
  1337.     va_start(args,methodID);
  1338.     result = functions->CallStaticShortMethodV(this,clazz,methodID,args);
  1339.     va_end(args);
  1340.     return result;
  1341.     }
  1342.     jshort CallStaticShortMethodV(jclass clazz,
  1343.                   jmethodID methodID, va_list args) {
  1344.         return functions->CallStaticShortMethodV(this,clazz,methodID,args);
  1345.     }
  1346.     jshort CallStaticShortMethodA(jclass clazz,
  1347.                   jmethodID methodID, jvalue *args) {
  1348.         return functions->CallStaticShortMethodA(this,clazz,methodID,args);
  1349.     }
  1350.  
  1351.     jint CallStaticIntMethod(jclass clazz,
  1352.                  jmethodID methodID, ...) {
  1353.         va_list args;
  1354.     jint result;
  1355.     va_start(args,methodID);
  1356.     result = functions->CallStaticIntMethodV(this,clazz,methodID,args);
  1357.     va_end(args);
  1358.     return result;
  1359.     }
  1360.     jint CallStaticIntMethodV(jclass clazz,
  1361.                   jmethodID methodID, va_list args) {
  1362.         return functions->CallStaticIntMethodV(this,clazz,methodID,args);
  1363.     }
  1364.     jint CallStaticIntMethodA(jclass clazz, 
  1365.                   jmethodID methodID, jvalue *args) {
  1366.         return functions->CallStaticIntMethodA(this,clazz,methodID,args);
  1367.     }
  1368.  
  1369.     jlong CallStaticLongMethod(jclass clazz,
  1370.                    jmethodID methodID, ...) {
  1371.         va_list args;
  1372.     jlong result;
  1373.     va_start(args,methodID);
  1374.     result = functions->CallStaticLongMethodV(this,clazz,methodID,args);
  1375.     va_end(args);
  1376.     return result;
  1377.     }
  1378.     jlong CallStaticLongMethodV(jclass clazz, 
  1379.                 jmethodID methodID, va_list args) {
  1380.         return functions->CallStaticLongMethodV(this,clazz,methodID,args);
  1381.     }
  1382.     jlong CallStaticLongMethodA(jclass clazz, 
  1383.                 jmethodID methodID, jvalue *args) {
  1384.         return functions->CallStaticLongMethodA(this,clazz,methodID,args);
  1385.     }
  1386.  
  1387.     jfloat CallStaticFloatMethod(jclass clazz, 
  1388.                  jmethodID methodID, ...) {
  1389.         va_list args;
  1390.     jfloat result;
  1391.     va_start(args,methodID);
  1392.     result = functions->CallStaticFloatMethodV(this,clazz,methodID,args);
  1393.     va_end(args);
  1394.     return result;
  1395.     }
  1396.     jfloat CallStaticFloatMethodV(jclass clazz, 
  1397.                   jmethodID methodID, va_list args) {
  1398.         return functions->CallStaticFloatMethodV(this,clazz,methodID,args);
  1399.     }
  1400.     jfloat CallStaticFloatMethodA(jclass clazz, 
  1401.                   jmethodID methodID, jvalue *args) {
  1402.         return functions->CallStaticFloatMethodA(this,clazz,methodID,args);
  1403.     }
  1404.  
  1405.     jdouble CallStaticDoubleMethod(jclass clazz, 
  1406.                    jmethodID methodID, ...) {
  1407.         va_list args;
  1408.     jdouble result;
  1409.     va_start(args,methodID);
  1410.     result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
  1411.     va_end(args);
  1412.     return result;
  1413.     }
  1414.     jdouble CallStaticDoubleMethodV(jclass clazz, 
  1415.                     jmethodID methodID, va_list args) {
  1416.         return functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
  1417.     }
  1418.     jdouble CallStaticDoubleMethodA(jclass clazz, 
  1419.                     jmethodID methodID, jvalue *args) {
  1420.         return functions->CallStaticDoubleMethodA(this,clazz,methodID,args);
  1421.     }
  1422.  
  1423.     void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {
  1424.         va_list args;
  1425.     va_start(args,methodID);
  1426.     functions->CallStaticVoidMethodV(this,cls,methodID,args);
  1427.     va_end(args);
  1428.     }
  1429.     void CallStaticVoidMethodV(jclass cls, jmethodID methodID, 
  1430.                    va_list args) {
  1431.         functions->CallStaticVoidMethodV(this,cls,methodID,args);
  1432.     }
  1433.     void CallStaticVoidMethodA(jclass cls, jmethodID methodID, 
  1434.                    jvalue * args) {
  1435.         functions->CallStaticVoidMethodA(this,cls,methodID,args);
  1436.     }
  1437.  
  1438.     jfieldID GetStaticFieldID(jclass clazz, const char *name, 
  1439.                   const char *sig) {
  1440.         return functions->GetStaticFieldID(this,clazz,name,sig);
  1441.     }
  1442.     jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) {
  1443.         return functions->GetStaticObjectField(this,clazz,fieldID);
  1444.     }
  1445.     jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) {
  1446.         return functions->GetStaticBooleanField(this,clazz,fieldID);
  1447.     }
  1448.     jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) {
  1449.         return functions->GetStaticByteField(this,clazz,fieldID);
  1450.     }
  1451.     jchar GetStaticCharField(jclass clazz, jfieldID fieldID) {
  1452.         return functions->GetStaticCharField(this,clazz,fieldID);
  1453.     }
  1454.     jshort GetStaticShortField(jclass clazz, jfieldID fieldID) {
  1455.         return functions->GetStaticShortField(this,clazz,fieldID);
  1456.     }
  1457.     jint GetStaticIntField(jclass clazz, jfieldID fieldID) {
  1458.         return functions->GetStaticIntField(this,clazz,fieldID);
  1459.     }
  1460.     jlong GetStaticLongField(jclass clazz, jfieldID fieldID) {
  1461.         return functions->GetStaticLongField(this,clazz,fieldID);
  1462.     }
  1463.     jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) {
  1464.         return functions->GetStaticFloatField(this,clazz,fieldID);
  1465.     }
  1466.     jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) {
  1467.         return functions->GetStaticDoubleField(this,clazz,fieldID);
  1468.     }
  1469.  
  1470.     void SetStaticObjectField(jclass clazz, jfieldID fieldID,
  1471.             jobject value) {
  1472.       functions->SetStaticObjectField(this,clazz,fieldID,value);
  1473.     }
  1474.     void SetStaticBooleanField(jclass clazz, jfieldID fieldID,
  1475.             jboolean value) {
  1476.       functions->SetStaticBooleanField(this,clazz,fieldID,value);
  1477.     }
  1478.     void SetStaticByteField(jclass clazz, jfieldID fieldID,
  1479.             jbyte value) {
  1480.       functions->SetStaticByteField(this,clazz,fieldID,value);
  1481.     }
  1482.     void SetStaticCharField(jclass clazz, jfieldID fieldID,
  1483.             jchar value) {
  1484.       functions->SetStaticCharField(this,clazz,fieldID,value);
  1485.     }
  1486.     void SetStaticShortField(jclass clazz, jfieldID fieldID,
  1487.             jshort value) {
  1488.       functions->SetStaticShortField(this,clazz,fieldID,value);
  1489.     }
  1490.     void SetStaticIntField(jclass clazz, jfieldID fieldID,
  1491.             jint value) {
  1492.       functions->SetStaticIntField(this,clazz,fieldID,value);
  1493.     }
  1494.     void SetStaticLongField(jclass clazz, jfieldID fieldID,
  1495.             jlong value) {
  1496.       functions->SetStaticLongField(this,clazz,fieldID,value);
  1497.     }
  1498.     void SetStaticFloatField(jclass clazz, jfieldID fieldID,
  1499.             jfloat value) {
  1500.       functions->SetStaticFloatField(this,clazz,fieldID,value);
  1501.     }
  1502.     void SetStaticDoubleField(jclass clazz, jfieldID fieldID,
  1503.             jdouble value) {
  1504.       functions->SetStaticDoubleField(this,clazz,fieldID,value);
  1505.     }
  1506.  
  1507.     jstring NewString(const jchar *unicode, jsize len) {
  1508.         return functions->NewString(this,unicode,len);
  1509.     }
  1510.     jsize GetStringLength(jstring str) {
  1511.         return functions->GetStringLength(this,str);
  1512.     }
  1513.     const jchar *GetStringChars(jstring str, jboolean *isCopy) {
  1514.         return functions->GetStringChars(this,str,isCopy);
  1515.     }
  1516.     void ReleaseStringChars(jstring str, const jchar *chars) {
  1517.         functions->ReleaseStringChars(this,str,chars);
  1518.     }
  1519.   
  1520.     jstring NewStringUTF(const char *utf) {
  1521.         return functions->NewStringUTF(this,utf);
  1522.     }
  1523.     jsize GetStringUTFLength(jstring str) {
  1524.         return functions->GetStringUTFLength(this,str);
  1525.     }
  1526.     const char* GetStringUTFChars(jstring str, jboolean *isCopy) {
  1527.         return functions->GetStringUTFChars(this,str,isCopy);
  1528.     }
  1529.     void ReleaseStringUTFChars(jstring str, const char* chars) {
  1530.         functions->ReleaseStringUTFChars(this,str,chars);
  1531.     }
  1532.  
  1533.     jsize GetArrayLength(jarray array) {
  1534.         return functions->GetArrayLength(this,array);
  1535.     }
  1536.  
  1537.     jobjectArray NewObjectArray(jsize len, jclass clazz, 
  1538.                 jobject init) {
  1539.         return functions->NewObjectArray(this,len,clazz,init);
  1540.     }
  1541.     jobject GetObjectArrayElement(jobjectArray array, jsize index) {
  1542.         return functions->GetObjectArrayElement(this,array,index);
  1543.     }
  1544.     void SetObjectArrayElement(jobjectArray array, jsize index, 
  1545.                    jobject val) {
  1546.         functions->SetObjectArrayElement(this,array,index,val);
  1547.     }
  1548.  
  1549.     jbooleanArray NewBooleanArray(jsize len) {
  1550.         return functions->NewBooleanArray(this,len);
  1551.     }
  1552.     jbyteArray NewByteArray(jsize len) {
  1553.         return functions->NewByteArray(this,len);
  1554.     }
  1555.     jcharArray NewCharArray(jsize len) {
  1556.         return functions->NewCharArray(this,len);
  1557.     }
  1558.     jshortArray NewShortArray(jsize len) {
  1559.         return functions->NewShortArray(this,len);
  1560.     }
  1561.     jintArray NewIntArray(jsize len) {
  1562.         return functions->NewIntArray(this,len);
  1563.     }
  1564.     jlongArray NewLongArray(jsize len) {
  1565.         return functions->NewLongArray(this,len);
  1566.     }
  1567.     jfloatArray NewFloatArray(jsize len) {
  1568.         return functions->NewFloatArray(this,len);
  1569.     }
  1570.     jdoubleArray NewDoubleArray(jsize len) {
  1571.         return functions->NewDoubleArray(this,len);
  1572.     }
  1573.  
  1574.     jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) {
  1575.         return functions->GetBooleanArrayElements(this,array,isCopy);
  1576.     }
  1577.     jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) {
  1578.         return functions->GetByteArrayElements(this,array,isCopy);
  1579.     }
  1580.     jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) {
  1581.         return functions->GetCharArrayElements(this,array,isCopy);
  1582.     }
  1583.     jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) {
  1584.         return functions->GetShortArrayElements(this,array,isCopy);
  1585.     }
  1586.     jint * GetIntArrayElements(jintArray array, jboolean *isCopy) {
  1587.         return functions->GetIntArrayElements(this,array,isCopy);
  1588.     }
  1589.     jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) {
  1590.         return functions->GetLongArrayElements(this,array,isCopy);
  1591.     }
  1592.     jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) {
  1593.         return functions->GetFloatArrayElements(this,array,isCopy);
  1594.     }
  1595.     jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) {
  1596.         return functions->GetDoubleArrayElements(this,array,isCopy);
  1597.     }
  1598.  
  1599.     void ReleaseBooleanArrayElements(jbooleanArray array, 
  1600.                      jboolean *elems,
  1601.                      jint mode) {
  1602.         functions->ReleaseBooleanArrayElements(this,array,elems,mode);
  1603.     }
  1604.     void ReleaseByteArrayElements(jbyteArray array, 
  1605.                   jbyte *elems,
  1606.                   jint mode) {
  1607.         functions->ReleaseByteArrayElements(this,array,elems,mode);
  1608.     }
  1609.     void ReleaseCharArrayElements(jcharArray array, 
  1610.                   jchar *elems,
  1611.                   jint mode) {
  1612.         functions->ReleaseCharArrayElements(this,array,elems,mode);
  1613.     }
  1614.     void ReleaseShortArrayElements(jshortArray array, 
  1615.                    jshort *elems,
  1616.                    jint mode) {
  1617.         functions->ReleaseShortArrayElements(this,array,elems,mode);
  1618.     }
  1619.     void ReleaseIntArrayElements(jintArray array, 
  1620.                  jint *elems,
  1621.                  jint mode) {
  1622.         functions->ReleaseIntArrayElements(this,array,elems,mode);
  1623.     }
  1624.     void ReleaseLongArrayElements(jlongArray array, 
  1625.                   jlong *elems,
  1626.                   jint mode) {
  1627.         functions->ReleaseLongArrayElements(this,array,elems,mode);
  1628.     }
  1629.     void ReleaseFloatArrayElements(jfloatArray array, 
  1630.                    jfloat *elems,
  1631.                    jint mode) {
  1632.         functions->ReleaseFloatArrayElements(this,array,elems,mode);
  1633.     }
  1634.     void ReleaseDoubleArrayElements(jdoubleArray array, 
  1635.                     jdouble *elems,
  1636.                     jint mode) {
  1637.         functions->ReleaseDoubleArrayElements(this,array,elems,mode);
  1638.     }
  1639.  
  1640.     void GetBooleanArrayRegion(jbooleanArray array, 
  1641.                    jsize start, jsize len, jboolean *buf) {
  1642.         functions->GetBooleanArrayRegion(this,array,start,len,buf);
  1643.     }
  1644.     void GetByteArrayRegion(jbyteArray array, 
  1645.                 jsize start, jsize len, jbyte *buf) {
  1646.         functions->GetByteArrayRegion(this,array,start,len,buf);
  1647.     }
  1648.     void GetCharArrayRegion(jcharArray array, 
  1649.                 jsize start, jsize len, jchar *buf) {
  1650.         functions->GetCharArrayRegion(this,array,start,len,buf);
  1651.     }
  1652.     void GetShortArrayRegion(jshortArray array, 
  1653.                  jsize start, jsize len, jshort *buf) {
  1654.         functions->GetShortArrayRegion(this,array,start,len,buf);
  1655.     }
  1656.     void GetIntArrayRegion(jintArray array, 
  1657.                jsize start, jsize len, jint *buf) {
  1658.         functions->GetIntArrayRegion(this,array,start,len,buf);
  1659.     }
  1660.     void GetLongArrayRegion(jlongArray array, 
  1661.                 jsize start, jsize len, jlong *buf) {
  1662.         functions->GetLongArrayRegion(this,array,start,len,buf);
  1663.     }
  1664.     void GetFloatArrayRegion(jfloatArray array, 
  1665.                  jsize start, jsize len, jfloat *buf) {
  1666.         functions->GetFloatArrayRegion(this,array,start,len,buf);
  1667.     }
  1668.     void GetDoubleArrayRegion(jdoubleArray array, 
  1669.                   jsize start, jsize len, jdouble *buf) {
  1670.         functions->GetDoubleArrayRegion(this,array,start,len,buf);
  1671.     }
  1672.  
  1673.     void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len, 
  1674.                    jboolean *buf) {
  1675.         functions->SetBooleanArrayRegion(this,array,start,len,buf);
  1676.     }
  1677.     void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,
  1678.                 jbyte *buf) {
  1679.         functions->SetByteArrayRegion(this,array,start,len,buf);
  1680.     }
  1681.     void SetCharArrayRegion(jcharArray array, jsize start, jsize len, 
  1682.                 jchar *buf) {
  1683.         functions->SetCharArrayRegion(this,array,start,len,buf);
  1684.     }
  1685.     void SetShortArrayRegion(jshortArray array, jsize start, jsize len, 
  1686.                  jshort *buf) {
  1687.         functions->SetShortArrayRegion(this,array,start,len,buf);
  1688.     }
  1689.     void SetIntArrayRegion(jintArray array, jsize start, jsize len,
  1690.                jint *buf) {
  1691.         functions->SetIntArrayRegion(this,array,start,len,buf);
  1692.     }
  1693.     void SetLongArrayRegion(jlongArray array, jsize start, jsize len,
  1694.                 jlong *buf) {
  1695.         functions->SetLongArrayRegion(this,array,start,len,buf);
  1696.     }
  1697.     void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len, 
  1698.                  jfloat *buf) {
  1699.         functions->SetFloatArrayRegion(this,array,start,len,buf);
  1700.     }
  1701.     void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
  1702.                   jdouble *buf) {
  1703.         functions->SetDoubleArrayRegion(this,array,start,len,buf);
  1704.     }
  1705.  
  1706.     jint RegisterNatives(jclass clazz, const JNINativeMethod *methods,
  1707.              jint nMethods) {
  1708.         return functions->RegisterNatives(this,clazz,methods,nMethods);
  1709.     }
  1710.     jint UnregisterNatives(jclass clazz) {
  1711.         return functions->UnregisterNatives(this,clazz);
  1712.     }  
  1713.    
  1714.     jint MonitorEnter(jobject obj) {
  1715.         return functions->MonitorEnter(this,obj);
  1716.     }
  1717.     jint MonitorExit(jobject obj) {
  1718.         return functions->MonitorExit(this,obj);
  1719.     }
  1720.  
  1721.     jint GetJavaVM(JavaVM **vm) {
  1722.         return functions->GetJavaVM(this,vm);
  1723.     }
  1724.   
  1725. #endif /* __cplusplus */
  1726. };
  1727.  
  1728. /* These structures will be VM-specific. */
  1729.  
  1730. typedef struct JDK1_1InitArgs {
  1731.     jint version;
  1732.  
  1733.     char **properties;
  1734.     jint checkSource; 
  1735.     jint nativeStackSize;
  1736.     jint javaStackSize;
  1737.     jint minHeapSize;
  1738.     jint maxHeapSize;
  1739.     jint verifyMode;
  1740.     char *classpath;
  1741.  
  1742.     jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args);
  1743.     void (JNICALL *exit)(jint code);
  1744.     void (JNICALL *abort)();
  1745.     
  1746.     jint enableClassGC;
  1747.     jint enableVerboseGC;
  1748.     jint disableAsyncGC;
  1749.     jint verbose;
  1750.     jboolean debugging;
  1751.     jint debugPort;
  1752. } JDK1_1InitArgs;
  1753.  
  1754. typedef struct JDK1_1AttachArgs {
  1755.     void * __padding; /* C compilers don't allow empty structures. */
  1756. } JDK1_1AttachArgs;
  1757.  
  1758. /* End VM-specific. */
  1759.  
  1760. struct JNIInvokeInterface_ {
  1761.     void *reserved0;
  1762.     void *reserved1;
  1763.     void *reserved2;
  1764.  
  1765.     jint (JNICALL *DestroyJavaVM)(JavaVM *vm);
  1766.  
  1767.     jint (JNICALL *AttachCurrentThread)
  1768.       (JavaVM *vm, JNIEnv **penv, void *args);
  1769.  
  1770.     jint (JNICALL *DetachCurrentThread)(JavaVM *vm);
  1771. };
  1772.  
  1773. struct JavaVM_ {
  1774.     const struct JNIInvokeInterface_ *functions;
  1775.     void *reserved0;
  1776.     void *reserved1;
  1777.     void *reserved2;
  1778. #ifdef __cplusplus
  1779.  
  1780.     jint DestroyJavaVM() {
  1781.         return functions->DestroyJavaVM(this);
  1782.     }
  1783.     jint AttachCurrentThread(JNIEnv **penv, void *args) {
  1784.         return functions->AttachCurrentThread(this, penv, args);
  1785.     }
  1786.     jint DetachCurrentThread() {
  1787.         return functions->DetachCurrentThread(this);
  1788.     }
  1789.  
  1790. #endif
  1791. };
  1792.  
  1793. jint JNICALL JNI_GetDefaultJavaVMInitArgs(void *);
  1794.  
  1795. jint JNICALL JNI_CreateJavaVM(JavaVM **, JNIEnv **, void *);
  1796.  
  1797. jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
  1798.  
  1799. #ifdef __cplusplus
  1800. } /* extern "C" */
  1801. #endif /* __cplusplus */
  1802.  
  1803. #endif /* JNI_H */
  1804.  
  1805.  
  1806.